// @ts-ignore
/* eslint-disable */
import request from '@/utils/request';

/** 上账 POST /fds/purchase/accountEntry */
export async function accountEntryUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.accountEntryUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/purchase/accountEntry', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 新增渠道 POST /fds/purchase/addChannel */
export async function addChannelUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.addChannelUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_97>('/fds/purchase/addChannel', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 新增保价 POST /fds/purchase/addInsured */
export async function addInsuredUsingPOST(body: API.Pinyin_39, options?: { [key: string]: any }) {
  return request<API.Pinyin_40>('/fds/purchase/addInsured', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 采购退库 POST /fds/purchase/addPurReturns */
export async function getPurReturnsListUsingPOST(
  body: API.Pinyin_96,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_99>('/fds/purchase/addPurReturns', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 新增返厂退库 POST /fds/purchase/addReturns */
export async function addReturnsUsingPOST(body: API.Pinyin_93, options?: { [key: string]: any }) {
  return request<API.Pinyin_49>('/fds/purchase/addReturns', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 新增返厂入库 POST /fds/purchase/addReturnsIn */
export async function addReturnsInUsingPOST(body: API.Pinyin_93, options?: { [key: string]: any }) {
  return request<API.Pinyin_49>('/fds/purchase/addReturnsIn', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 追加商品 POST /fds/purchase/appendPurchase */
export async function appendPurchaseUsingPOST(
  body: API.Pinyin_96,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_99>('/fds/purchase/appendPurchase', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 追加退库 POST /fds/purchase/appendPurReturns */
export async function appendPurReturnsUsingPOST(
  body: API.Pinyin_96,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_99>('/fds/purchase/appendPurReturns', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 采购入库-自动编码入库 POST /fds/purchase/autoCodePurchase */
export async function autoCodePurchaseUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.autoCodePurchaseUsingPOSTParams,
  body: API.__8[],
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_99>('/fds/purchase/autoCodePurchase', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    params: {
      ...params,
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除渠道 POST /fds/purchase/deleteChannel */
export async function deleteChannelUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.deleteChannelUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/purchase/deleteChannel', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 撤销退库记录 POST /fds/purchase/deleteOutPurchase */
export async function deleteOutPurchaseUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.deleteOutPurchaseUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/purchase/deleteOutPurchase', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 删除退库库记录详情 POST /fds/purchase/deleteOutPurDetail */
export async function deleteOutPurDetailUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.deleteOutPurDetailUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/purchase/deleteOutPurDetail', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 撤销入库记录 POST /fds/purchase/deletePurchase */
export async function deletePurchaseUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.deletePurchaseUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/purchase/deletePurchase', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 删除入库记录详情 POST /fds/purchase/deletePurDetail */
export async function deletePurDetailUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.deletePurDetailUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/purchase/deletePurDetail', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 撤销返厂记录 POST /fds/purchase/deleteReturns */
export async function deleteReturnsUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.deleteReturnsUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/purchase/deleteReturns', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 采购入库-自动编码入库-excel导入 POST /fds/purchase/exportAutoCodePurchase */
export async function exportAutoCodePurchaseUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportAutoCodePurchaseUsingPOSTParams,
  body: {},
  file?: File,
  options?: { [key: string]: any },
) {
  const formData = new FormData();

  if (file) {
    formData.append('file', file);
  }

  Object.keys(body).forEach((ele) => {
    const item = (body as any)[ele];

    if (item !== undefined && item !== null) {
      formData.append(
        ele,
        typeof item === 'object' && !(item instanceof File) ? JSON.stringify(item) : item,
      );
    }
  });

  return request<API.Pinyin_99>('/fds/purchase/exportAutoCodePurchase', {
    method: 'POST',
    params: {
      ...params,
    },
    data: formData,
    requestType: 'form',
    ...(options || {}),
  });
}

/** 导出变更记录列表 POST /fds/purchase/exportChangeRecord */
export async function exportChangeRecordUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportChangeRecordUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/purchase/exportChangeRecord', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出渠道 POST /fds/purchase/exportChanne */
export async function exportChanneUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportChanneUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/purchase/exportChanne', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出保价记录详情列表 POST /fds/purchase/exportInsDetail */
export async function exportInsDetailUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportInsDetailUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/purchase/exportInsDetail', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出保价记录列表 POST /fds/purchase/exportInsured */
export async function exportInsuredUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportInsuredUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/purchase/exportInsured', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出流转记录列表 POST /fds/purchase/exportInvRecord */
export async function exportInvRecordUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportInvRecordUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/purchase/exportInvRecord', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 采购入库-手动入库-excel导入 POST /fds/purchase/exportManualPurchase */
export async function exportManualPurchaseUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportManualPurchaseUsingPOSTParams,
  body: {},
  file?: File,
  options?: { [key: string]: any },
) {
  const formData = new FormData();

  if (file) {
    formData.append('file', file);
  }

  Object.keys(body).forEach((ele) => {
    const item = (body as any)[ele];

    if (item !== undefined && item !== null) {
      formData.append(
        ele,
        typeof item === 'object' && !(item instanceof File) ? JSON.stringify(item) : item,
      );
    }
  });

  return request<API.Pinyin_99>('/fds/purchase/exportManualPurchase', {
    method: 'POST',
    params: {
      ...params,
    },
    data: formData,
    requestType: 'form',
    ...(options || {}),
  });
}

/** 导出操作记录列表 POST /fds/purchase/exportOperRecordList */
export async function exportOperRecordListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportOperRecordListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/purchase/exportOperRecordList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出入库/退库记录 POST /fds/purchase/exportPurchase */
export async function exportPurchaseUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportPurchaseUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/purchase/exportPurchase', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出采购记录详情 POST /fds/purchase/exportPurDetail */
export async function exportPurDetailUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportPurDetailUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/purchase/exportPurDetail', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出采购记录详情汇总 POST /fds/purchase/exportPurDetailSummary */
export async function exportPurDetailSummaryUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportPurDetailSummaryUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/purchase/exportPurDetailSummary', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出返厂记录详情列表 POST /fds/purchase/exportRetDetail */
export async function exportRetDetailUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportRetDetailUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/purchase/exportRetDetail', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出返厂记录列表 POST /fds/purchase/exportReturns */
export async function exportReturnsUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportReturnsUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/purchase/exportReturns', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取变更记录列表 GET /fds/purchase/getChangeRecordList */
export async function getChangeRecordListUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getChangeRecordListUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult19>('/fds/purchase/getChangeRecordList', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取渠道 GET /fds/purchase/getChannel */
export async function getChannelUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getChannelUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_97>('/fds/purchase/getChannel', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取渠道列表 POST /fds/purchase/getChannelList */
export async function getChannelListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getChannelListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult40>('/fds/purchase/getChannelList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取保价记录详情列表 POST /fds/purchase/getInsDetailList */
export async function getInsDetailListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getInsDetailListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultInsDetailDto_>('/fds/purchase/getInsDetailList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取保价记录详情 GET /fds/purchase/getInsured */
export async function getInsuredUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getInsuredUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.InsuredDto>('/fds/purchase/getInsured', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取保价记录列表 POST /fds/purchase/getInsuredList */
export async function getInsuredListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getInsuredListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultInsuredDto_>('/fds/purchase/getInsuredList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取流转记录列表 GET /fds/purchase/getInvRecordList */
export async function getInvRecordListUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getInvRecordListUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult25>('/fds/purchase/getInvRecordList', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取操作记录列表 POST /fds/purchase/getOperRecordList */
export async function getOperRecordListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getOperRecordListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultOrderOperRecordDto_>('/fds/purchase/getOperRecordList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取入库/退库详情 GET /fds/purchase/getPurchase */
export async function getPurchaseUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getPurchaseUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_19>('/fds/purchase/getPurchase', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取入库商品清单 POST /fds/purchase/getPurchaseList */
export async function getPurchaseListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getPurchaseListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult41>('/fds/purchase/getPurchaseList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取入库/退库记录详情列表 POST /fds/purchase/getPurDetailList */
export async function getPurDetailListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getPurDetailListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultPurDetailDto_>('/fds/purchase/getPurDetailList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取入库/退库记录列表 POST /fds/purchase/getPurList */
export async function getPurListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getPurListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult14>('/fds/purchase/getPurList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取返厂记录详情列表 POST /fds/purchase/getRetDetailList */
export async function getRetDetailListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getRetDetailListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultRetDetailDto_>('/fds/purchase/getRetDetailList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取返厂记录信息 GET /fds/purchase/getReturns */
export async function getReturnsUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getReturnsUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.ReturnsDto>('/fds/purchase/getReturns', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取返厂记录列表 POST /fds/purchase/getReturnsList */
export async function getReturnsListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getReturnsListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultReturnsDto_>('/fds/purchase/getReturnsList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 保价审核 POST /fds/purchase/InsuredCheckPur */
export async function insuredCheckPurUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.insuredCheckPurUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/purchase/InsuredCheckPur', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 保价反审核 POST /fds/purchase/InsuredUnCheckPur */
export async function insuredUnCheckPurUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.insuredUnCheckPurUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/purchase/InsuredUnCheckPur', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 采购入库-手动入库 POST /fds/purchase/manualPurchase */
export async function manualPurchaseUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.manualPurchaseUsingPOSTParams,
  body: API.__7[],
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_99>('/fds/purchase/manualPurchase', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    params: {
      ...params,
    },
    data: body,
    ...(options || {}),
  });
}

/** 采购审核 POST /fds/purchase/purchaseCheckPur */
export async function purchaseCheckPurUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.purchaseCheckPurUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/purchase/purchaseCheckPur', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 采购反审核 POST /fds/purchase/purchaseUnCheckPur */
export async function purchaseUnCheckPurUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.purchaseUnCheckPurUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/purchase/purchaseUnCheckPur', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取入库/退库记录详情汇总 POST /fds/purchase/purDetailSummary */
export async function purDetailSummaryUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.purDetailSummaryUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultPurDetailSummary_>('/fds/purchase/purDetailSummary', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 退库审核 POST /fds/purchase/PurReturnsCheckPur */
export async function purReturnsCheckPurUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.purReturnsCheckPurUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/purchase/PurReturnsCheckPur', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 退库反审核 POST /fds/purchase/PurReturnsUnCheckPur */
export async function purReturnsUnCheckPurUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.purReturnsUnCheckPurUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/purchase/PurReturnsUnCheckPur', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 返厂审核 POST /fds/purchase/returnsCheckPur */
export async function returnsCheckPurUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.returnsCheckPurUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/purchase/returnsCheckPur', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 返厂反审核 POST /fds/purchase/returnsUnCheckPur */
export async function returnsUnCheckPurUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.returnsUnCheckPurUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/purchase/returnsUnCheckPur', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 撤销保价记录 POST /fds/purchase/revokeInsured */
export async function revokeInsuredUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.revokeInsuredUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/purchase/revokeInsured', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 修改渠道 POST /fds/purchase/updateChannel */
export async function updateChannelUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.updateChannelUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_97>('/fds/purchase/updateChannel', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 修改保价记录详情 POST /fds/purchase/updateInsDetail */
export async function updateInsDetailUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.updateInsDetailUsingPOSTParams,
  body: API.Pinyin_16[],
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_40>('/fds/purchase/updateInsDetail', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    params: {
      ...params,
    },
    data: body,
    ...(options || {}),
  });
}

/** 修改保价记录信息 POST /fds/purchase/updateInsured */
export async function updateInsuredUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.updateInsuredUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_40>('/fds/purchase/updateInsured', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 修改退库记录 POST /fds/purchase/updateOutPurchase */
export async function updateOutPurchaseUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.updateOutPurchaseUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_99>('/fds/purchase/updateOutPurchase', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 修改退库记录详情信息 POST /fds/purchase/updateOutPurDetail */
export async function updateOutPurDetailUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.updateOutPurDetailUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_98>('/fds/purchase/updateOutPurDetail', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 修改入库记录 POST /fds/purchase/updatePurchase */
export async function updatePurchaseUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.updatePurchaseUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_99>('/fds/purchase/updatePurchase', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 修改入库记录详情信息 POST /fds/purchase/updatePurDetail */
export async function updatePurDetailUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.updatePurDetailUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_98>('/fds/purchase/updatePurDetail', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 修改返厂记录信息 POST /fds/purchase/updateReturns */
export async function updateReturnsUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.updateReturnsUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_49>('/fds/purchase/updateReturns', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}
